home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Utilities / Post / Source / PostMenu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-01  |  16.9 KB  |  728 lines

  1. #include "PostPre.h"
  2. #include "PostWin.h"
  3. #include "Global.h"
  4.  
  5. char    hailfilef[]        = "Select font to load";
  6. char    hailfilen[]        = "Select file to load";
  7. char    hailfiles[]        = "Select file to run";
  8. char    useopts[3][15] = {"ENV:POST","ENV:POST.iff","ENV:POST.print"};
  9. char    saveopts[3][20]= {"ENVARC:POST","ENVARC:POST.iff","ENVARC:POST.print"};
  10. char    command[256], newpubscreenname[MAXPUBSCREENNAME+1];
  11.  
  12. int    next_page_number, opt_number;
  13.  
  14. struct    Requester sleep_req;
  15. struct    List    NewPubScrList;
  16. struct    PubScrContext newpubscrcontext = {NULL, FALSE, FALSE, FALSE};
  17.  
  18.  
  19. void    sleep_OutputWnd(void)
  20. {
  21.     if(OutputWnd == NULL) return;
  22.     ModifyIDCMP(OutputWnd, IDCMP_REFRESHWINDOW | IDCMP_NEWSIZE |
  23.         IDCMP_GADGETUP | IDCMP_GADGETDOWN | IDCMP_MENUPICK | IDCMP_CLOSEWINDOW |
  24.         IDCMP_MOUSEMOVE | IDCMP_SIZEVERIFY | IDCMP_ACTIVEWINDOW |
  25.         IDCMP_INACTIVEWINDOW | IDCMP_CHANGEWINDOW | IDCMP_IDCMPUPDATE |
  26.         IDCMP_RAWKEY | IDCMP_VANILLAKEY);
  27.     InitRequester(&sleep_req);
  28.     Request(&sleep_req, OutputWnd);
  29.     if(os_3) SetWindowPointer(OutputWnd, WA_BusyPointer, TRUE, WA_PointerDelay, TRUE, TAG_DONE);
  30. }
  31.  
  32. void    awake_OutputWnd(void)
  33. {
  34.     if(OutputWnd == NULL) return;
  35.     ModifyIDCMP(OutputWnd, IDCMP_REFRESHWINDOW | IDCMP_NEWSIZE |
  36.         IDCMP_GADGETUP | IDCMP_GADGETDOWN | IDCMP_MENUPICK | IDCMP_CLOSEWINDOW |
  37.         IDCMP_MOUSEMOVE | IDCMP_SIZEVERIFY | IDCMP_ACTIVEWINDOW |
  38.         IDCMP_INACTIVEWINDOW | IDCMP_MENUVERIFY | IDCMP_CHANGEWINDOW |
  39.         IDCMP_IDCMPUPDATE | IDCMP_RAWKEY | IDCMP_VANILLAKEY);
  40.     EndRequest(&sleep_req, OutputWnd);
  41.     if(os_3) SetWindowPointer(OutputWnd, WA_Pointer, NULL, TAG_DONE);
  42. }
  43.  
  44. int MenuNew( void )
  45. {
  46.     /* routine when (sub)item "New" is selected. */
  47.  
  48.     int    retc;
  49.  
  50.     opt_number = MENU_NEW;
  51.     if(OpenOptionsWindow()) 
  52.     {
  53.         okmsg("can't open options window!");
  54.         CloseOptionsWindow();
  55.         return(0);
  56.     }
  57.     sleep_OutputWnd();
  58.     SetWindowTitles(OptionsWnd, "Options for the new Post Window", "Options for the new Post Window");
  59.     copy_options(&TempOptions, &NewOptions);
  60.     setoptionsgadgets(MENU_NEW);
  61.     for(;;)
  62.     {
  63.         WaitPort(OptionsWnd->UserPort);
  64.         retc = HandleOptionsIDCMP();
  65.         if(retc == Options_CANCEL || retc == Options_OK) break;
  66.     }
  67.     CloseOptionsWindow();
  68.     awake_OutputWnd();
  69.     if(retc == Options_OK)
  70.     {
  71.         copy_options(&NewOptions, &TempOptions);
  72.         sprintf(command, "run > NIL: POST:Post PUBSCREEN %s OPTFILE ENV:POST",
  73.                     Options.Screen.custscreen ? postpubscrname : pubscreenname);
  74.         SystemTagList(command, TAG_END);
  75.     }
  76.     return(0);
  77. }
  78.  
  79. int MenuClear( void )
  80. {
  81.     /* routine when (sub)item "Clear" is selected. */
  82.  
  83.  
  84.     saveterminate();
  85.     sendmenu(PSACTCLEAR, 0, 0, 0, NULL, NULL);
  86.     Wait(1L << create_signal);
  87.     if(createerror)
  88.     {
  89.         errorende();
  90.         exit(10);
  91.     }
  92.     runstartupfiles();
  93.     return(0);
  94. }
  95.  
  96. int MenuOpen( void )
  97. {
  98.     /* routine when (sub)item "Open File..." is selected. */
  99.  
  100.     filereq = filerequester;
  101.     if (AslRequestTags(filereq,
  102.         ASLFR_TitleText,    (ULONG) hailfilen,
  103.         ASLFR_Window,        (ULONG) OutputWnd,
  104.         TAG_DONE) == NULL) return(0);
  105.     getfullfilename(Options.lastfile, filereq->rf_Dir, filereq->rf_File);
  106.     sendfile(PSACTFILE);
  107.     return(0);
  108. }
  109.  
  110. int MenuRun( void )
  111. {
  112.     /* routine when (sub)item "Run File ..." is selected. */
  113.  
  114.     filereq = filerequester;
  115.     if (AslRequestTags(filereq,
  116.         ASLFR_TitleText,    (ULONG) hailfiles,
  117.         ASLFR_Window,        (ULONG) OutputWnd,
  118.         TAG_DONE) == NULL) return(0);
  119.     getfullfilename(Options.lastfile, filereq->rf_Dir, filereq->rf_File);
  120.     sendfile(PSACTRUN);
  121.     return(0);
  122. }
  123.  
  124. int MenuFont( void )
  125. {
  126.     /* routine when (sub)item "Load Font ..." is selected. */
  127.  
  128.     filereq = fontrequester;
  129.     if (AslRequestTags(filereq,
  130.         ASLFR_InitialPattern,    (ULONG) "~(#?.afm|#?.info)",
  131.         ASLFR_InitialDrawer,        (ULONG) "PSFONTS:",
  132.         ASLFR_InitialFile,         (ULONG) "",
  133.         ASLFR_InitialHeight,     300,
  134.         ASLFR_TitleText,            (ULONG) hailfilef,
  135.         ASLFR_DoSaveMode,            FALSE,
  136.         ASLFR_Window,                (ULONG) OutputWnd,
  137.         TAG_DONE) == NULL) return(0);
  138.     getfullfilename(Options.lastfile, filereq->rf_Dir, filereq->rf_File);
  139.     sendfile(PSACTFONT);
  140.     return(0);
  141. }
  142.  
  143. int MenuIff( void )
  144. {
  145.     /* routine when (sub)item "Save As Iff ..." is selected. */
  146.  
  147.     int    retc;
  148.  
  149.     if(running == FALSE)
  150.     {
  151.         filereq = filerequester;
  152.         if (AslRequestTags(filereq,
  153.             ASLFR_TitleText,    (ULONG) "Select file to save ...",
  154.             ASLFR_Window,        (ULONG) OutputWnd,
  155.             TAG_DONE) == NULL) return(0);
  156.         strcpy(Options.lastdir, filereq->rf_Dir);
  157.         getfullfilename(Options.lastfile, filereq->rf_Dir, filereq->rf_File);
  158.         number_of_pages = splitpage(Options.lastfile);
  159.     }
  160.     opt_number = MENU_IFF;
  161.     if(OpenOptionsWindow()) 
  162.     {
  163.         okmsg("can't open options window!");
  164.         CloseOptionsWindow();
  165.         return(0);
  166.     }
  167.     sleep_OutputWnd();
  168.     SetWindowTitles(OptionsWnd, "Options for the IFF-File", "Options for the IFF-File");
  169.     copy_options(&TempOptions, &IffOptions);
  170.     if(number_of_pages == 0)
  171.     {
  172.         TempOptions.PostOpts.bandrendering = FALSE;
  173.         TempOptions.PostOpts.allpages = TRUE;
  174.         TempOptions.PostOpts.from = 0;
  175.         TempOptions.PostOpts.to = 0;
  176.     }
  177.     else
  178.     {
  179.         TempOptions.PostOpts.from = 1;
  180.         TempOptions.PostOpts.to = number_of_pages;
  181.     }
  182.     setoptionsgadgets(MENU_IFF);
  183.     GT_SetGadgetAttrs(OptionsGadgets[GD_OptGetIff], OptionsWnd, NULL,
  184.         GA_Disabled, FALSE, TAG_DONE);
  185.     GT_SetGadgetAttrs(OptionsGadgets[GD_OptIff], OptionsWnd, NULL,
  186.         GA_Disabled, FALSE, TAG_DONE);
  187.     for(;;)
  188.     {
  189.         WaitPort(OptionsWnd->UserPort);
  190.         retc = HandleOptionsIDCMP();
  191.         if(retc == Options_CANCEL || retc == Options_OK) break;
  192.     }
  193.     CloseOptionsWindow();
  194.     awake_OutputWnd();
  195.     if(retc == Options_OK)
  196.     {
  197.         copy_options(&IffOptions, &TempOptions);
  198.         sprintf(command, "run >nil: POST:Post IFF %s OPTFILE ENV:POST.iff FILE %s PUBSCREEN %s CONWIN VERBOSE",
  199.                     (char *) &(TempOptions.PostOpts.iffname), Options.lastfile, Options.Screen.custscreen ? postpubscrname : pubscreenname);
  200.         SystemTagList(command, TAG_END);
  201.     }
  202.     return(0);
  203. }
  204.  
  205. int MenuPrint( void )
  206. {
  207.     /* routine when (sub)item "Print ..." is selected. */
  208.  
  209.     int    retc;
  210.  
  211.     if(running == FALSE)
  212.     {
  213.         filereq = filerequester;
  214.         if (AslRequestTags(filereq,
  215.             ASLFR_TitleText,    (ULONG) "Select file to print ...",
  216.             ASLFR_Window,        (ULONG) OutputWnd,
  217.             TAG_DONE) == NULL) return(0);
  218.         strcpy(Options.lastdir, filereq->rf_Dir);
  219.         getfullfilename(Options.lastfile, filereq->rf_Dir, filereq->rf_File);
  220.         number_of_pages = splitpage(Options.lastfile);
  221.     }
  222.     opt_number = MENU_PRINT;
  223.     if(OpenOptionsWindow()) 
  224.     {
  225.         okmsg("can't open options window!");
  226.         CloseOptionsWindow();
  227.         return(0);
  228.     }
  229.     sleep_OutputWnd();
  230.     SetWindowTitles(OptionsWnd, "Print Options", "Print Options");
  231.     copy_options(&TempOptions, &PrintOptions);
  232.     if(number_of_pages == 0)
  233.     {
  234.         TempOptions.PostOpts.bandrendering = FALSE;
  235.         TempOptions.PostOpts.allpages = TRUE;
  236.         TempOptions.PostOpts.from = 0;
  237.         TempOptions.PostOpts.to = 0;
  238.     }
  239.     else
  240.     {
  241.         TempOptions.PostOpts.from = 1;
  242.         TempOptions.PostOpts.to = number_of_pages;
  243.     }
  244.     setoptionsgadgets(MENU_PRINT);
  245.     GT_SetGadgetAttrs(OptionsGadgets[GD_OptPrDen], OptionsWnd, NULL,
  246.         GA_Disabled, FALSE, TAG_DONE);
  247.     GT_SetGadgetAttrs(OptionsGadgets[GD_OptCenter], OptionsWnd, NULL,
  248.         GA_Disabled, FALSE, TAG_DONE);
  249.     GT_SetGadgetAttrs(OptionsGadgets[GD_OptFF], OptionsWnd, NULL,
  250.         GA_Disabled, FALSE, TAG_DONE);
  251.  
  252.     for(;;)
  253.     {
  254.         WaitPort(OptionsWnd->UserPort);
  255.         retc = HandleOptionsIDCMP();
  256.         if(retc == Options_CANCEL || retc == Options_OK) break;
  257.     }
  258.     CloseOptionsWindow();
  259.     awake_OutputWnd();
  260.     if(retc == Options_OK)
  261.     {
  262.         copy_options(&PrintOptions, &TempOptions);
  263.         sprintf(command, "run > NIL: POST:Post PRINTER OPTFILE ENV:POST.print FILE %s PUBSCREEN %s CONWIN VERBOSE",
  264.                     Options.lastfile, Options.Screen.custscreen ? postpubscrname : pubscreenname);
  265.         SystemTagList(command, TAG_END);
  266.     }
  267.     return(0);
  268. }
  269.  
  270. int MenuAbout( void )
  271. {
  272.     /* routine when (sub)item "About ..." is selected. */
  273.  
  274.     struct EasyStruct myES =
  275.     {
  276.         sizeof(struct EasyStruct),
  277.         0,
  278.         "About Post:",
  279.         "%s\n\n"
  280.         "post.library:       %ld.%ld\n"
  281.         "Public screen name: %s\n"
  282.         "%s\n"
  283.         "Based on Post V1.7     © 1989, 1992 Adrian Aylward,\n"
  284.         "              V1.86enh © 1993 Robert Poole,\n"
  285.         "              V2.00    © 1997 Christian Eibl\n",
  286.         "Ok",
  287.     };
  288.     char    *an, string[25];
  289.  
  290.     if(an = ARexxName(RexxStuff))
  291.     {
  292.         sprintf(string, "ARexx port name:    %s\n", an);
  293.     }
  294.     else
  295.     {
  296.         string[0] = 0;
  297.     }
  298.     EasyRequest(OutputWnd, &myES, NULL, (ULONG) &version[6],
  299.                     PSbase->lib_Version, PSbase->lib_Revision,
  300.                     (ULONG) (Options.Screen.custscreen ? postpubscrname : pubscreenname),
  301.                     (ULONG) string);
  302.     return(0);
  303. }
  304.  
  305. int MenuQuit( void )
  306. {
  307.     /* routine when (sub)item "Quit" is selected. */
  308.  
  309.     SavePostOptions("ENV:Post", &Options);
  310.     errorende();
  311.     exit(0);
  312.     return(0);
  313. }
  314.  
  315. int MenuPause( void )
  316. {
  317.     /* routine when (sub)item "Pause Every Page" is selected. */
  318.  
  319.     pause = !pause;
  320.     return(0);
  321. }
  322.  
  323. int MenuNext( void )
  324. {
  325.     /* routine when (sub)item "Next Page" is selected. */
  326.  
  327.     nextpage();
  328.     return(0);
  329. }
  330.  
  331. int MenuPrevious( void )
  332. {
  333.     /* routine when (sub)item "Previous Page" is selected. */
  334.  
  335.     previouspage();
  336.     return(0);
  337. }
  338.  
  339. int MenuGoto( void )
  340. {
  341.     /* routine when (sub)item "Goto Page ..." is selected. */
  342.  
  343.     int    retc;
  344.  
  345.     if(running && paused && number_of_pages)
  346.     {
  347.         if(OpenGotoPageWindow()) 
  348.         {
  349.             okmsg("can't open selection window!");
  350.             CloseGotoPageWindow();
  351.             return(0);
  352.         }
  353.         sleep_OutputWnd();
  354.         next_page_number = page_number + 1;
  355.         if(next_page_number == number_of_pages + 1) next_page_number = 1;
  356.         GT_SetGadgetAttrs(GotoPageGadgets[GD_GotoPage], GotoPageWnd, NULL,
  357.             GTIN_Number, next_page_number, TAG_DONE);
  358.         ActivateGadget(GotoPageGadgets[GD_GotoPage], GotoPageWnd, NULL);
  359.         for(;;)
  360.         {
  361.             WaitPort(GotoPageWnd->UserPort);
  362.             retc = HandleGotoPageIDCMP();
  363.             if(retc == GotoPage_CANCEL || retc == GotoPage_OK) break;
  364.         }
  365.         CloseGotoPageWindow();
  366.         awake_OutputWnd();
  367.         if(retc == GotoPage_OK)
  368.         {
  369.             if(page_number != next_page_number)
  370.             {
  371.                 Signal((struct Task *) rendertask, 1L << pause_signal);
  372.                 page_number = next_page_number;
  373.                 sendmenu(PSACTPAUSE, number_of_pages, page_number, 0, NULL, NULL);
  374.             }
  375.         }
  376.     }
  377.     return(0);
  378. }
  379.  
  380. int MenuInterrupt( void )
  381. {
  382.     /* routine when (sub)item "Interrupt" is selected. */
  383.  
  384.     if(running && !paused) PSsignalint(arec, 1);
  385.     return(0);
  386. }
  387.  
  388. int MenuKill( void )
  389. {
  390.     /* routine when (sub)item "Kill" is selected. */
  391.  
  392.     if(running && !paused) PSsignalint(arec, 2);
  393.     return(0);
  394. }
  395.  
  396. int MenuInteractive( void )
  397. {
  398.     /* routine when (sub)item "Interactive" is selected. */
  399.  
  400.     saveterminate();
  401.     sendmenu(PSACTINTER, 0, 0, 0, "%stdin", NULL);
  402.     return(0);
  403. }
  404.  
  405. int MenuPubScreen( void )
  406. {
  407.     /* routine when (sub)item "Public Screen" is selected. */
  408.  
  409.     struct    List *pubscrlist;
  410.     struct    Node *node, *nextnode;
  411.     struct    PubScrNode *PubScrNode;
  412.     int        retc, i, selected=0;
  413.  
  414.     NewList(&NewPubScrList);
  415.     pubscrlist = LockPubScreenList();
  416.     for(node = pubscrlist->lh_Head, i=0; node->ln_Succ; node = node->ln_Succ,i++)
  417.     {
  418.         if(!strcmp(node->ln_Name, postpubscrname)) continue;
  419.         if(!strcmp(node->ln_Name, pubscreenname))
  420.         {
  421.             selected = i;
  422.             strcpy(newpubscreenname, node->ln_Name);
  423.         }
  424.         PubScrNode = (struct PubScrNode *) malloc(sizeof(struct PubScrNode));
  425.         PubScrNode->node.ln_Name = PubScrNode->name;
  426.         strcpy(PubScrNode->name, node->ln_Name);
  427.         AddTail(&NewPubScrList, (struct Node *) PubScrNode);
  428.     }
  429.     UnlockPubScreenList();
  430.     if(NewPubScrList.lh_TailPred == (struct Node *) &NewPubScrList)
  431.     {
  432.         okmsg("no public screens available!");
  433.         return(0);
  434.     }
  435.  
  436.     if(OpenChoosePSWindow()) 
  437.     {
  438.         okmsg("can't open selection window!");
  439.         CloseChoosePSWindow();
  440.         for(node = NewPubScrList.lh_Head; node->ln_Succ;)
  441.         {
  442.             nextnode=node->ln_Succ;
  443.             free(node);
  444.             node=nextnode;
  445.         }
  446.         return(0);
  447.     }
  448.     sleep_OutputWnd();
  449.     GT_SetGadgetAttrs(ChoosePSGadgets[GD_PubScreenLV], ChoosePSWnd, NULL,
  450.         GTLV_Labels, (ULONG) &NewPubScrList, GTLV_Selected, selected, GTLV_Top, selected, TAG_DONE);
  451.     for(;;)
  452.     {
  453.         WaitPort(ChoosePSWnd->UserPort);
  454.         retc = HandleChoosePSIDCMP();
  455.         if(retc == ChoosePS_CANCEL || retc == ChoosePS_OK) break;
  456.     }
  457.     CloseChoosePSWindow();
  458.     awake_OutputWnd();
  459.     for(node = NewPubScrList.lh_Head; node->ln_Succ;)
  460.     {
  461.             nextnode=node->ln_Succ;
  462.             free(node);
  463.             node=nextnode;
  464.     }
  465.     if(retc == ChoosePS_OK && strcmp(newpubscreenname, postpubscrname))
  466.     {
  467.         if(do_pubscreen()) return(0);
  468.     }
  469.     return(0);
  470. }
  471.  
  472. int MenuCustomScreen( void )
  473. {
  474.     /* routine when (sub)item "Custom Screen" is selected. */
  475.  
  476.     if(!Menu_ScreenMode())
  477.     {
  478.         do_screen();
  479.     }
  480.     return(0);
  481. }
  482.  
  483. int MenuOptions( void )
  484. {
  485.     /* routine when (sub)item "Options ..." is selected. */
  486.  
  487.     int    retc;
  488.     BOOL    exitnext = FALSE;
  489.     struct    Options    Options_bak;
  490.  
  491.     opt_number = MENU_NEW;
  492.     copy_options(&TempOptions, &Options);
  493.     copy_options(&Options_bak, &Options);
  494. nochmal:
  495.     if(OpenOptionsWindow()) 
  496.     {
  497.         okmsg("can't open options window!");
  498.         CloseOptionsWindow();
  499.         return(0);
  500.     }
  501.     sleep_OutputWnd();
  502.     SetWindowTitles(OptionsWnd, "Options for this Post Window", "Options for this Post Window");
  503.     setoptionsgadgets(MENU_NEW);
  504.     for(;;)
  505.     {
  506.         WaitPort(OptionsWnd->UserPort);
  507.         retc = HandleOptionsIDCMP();
  508.         if(retc == Options_CANCEL || retc == Options_OK) break;
  509.     }
  510.     CloseOptionsWindow();
  511.     awake_OutputWnd();
  512.     if(retc == Options_OK)
  513.     {
  514.         if(exitnext = do_opts())
  515.         {
  516.             copy_options(&TempOptions, &Options_bak);
  517.             SavePostOptions("ENV:Post", &Options_bak);
  518.             goto nochmal;
  519.         }
  520.     }
  521.     else if(exitnext)
  522.     {
  523.         errorende();
  524.         exit(20);
  525.     }
  526.     return(0);
  527. }
  528.  
  529.  
  530.  
  531. int PubScreenLVClicked( void )
  532. {
  533.     /* routine when gadget "" is clicked. */
  534.  
  535.     struct  Node    *node;
  536.     int     i;
  537.  
  538.     node = NewPubScrList.lh_Head;
  539.     for(i=0; i < ChoosePSMsg.Code; i++) 
  540.     {
  541.         node = node->ln_Succ;
  542.     }
  543.     strcpy(newpubscreenname, node->ln_Name);
  544.     return(0);
  545. }
  546.  
  547. int CPSCancelClicked( void )
  548. {
  549.     /* routine when gadget "_Cancel" is clicked. */
  550.  
  551.     return(ChoosePS_CANCEL);
  552. }
  553.  
  554. int CPSOkClicked( void )
  555. {
  556.     /* routine when gadget "_Ok" is clicked. */
  557.  
  558.     return(ChoosePS_OK);
  559. }
  560.  
  561. int GotoPageClicked( void )
  562. {
  563.     /* routine when gadget "Page Number:" is clicked. */
  564.  
  565.     next_page_number = GetNumber(GotoPageGadgets[GD_GotoPage]);
  566.     if(next_page_number < 1)
  567.     {
  568.         next_page_number = 1;
  569.         GT_SetGadgetAttrs(GotoPageGadgets[GD_GotoPage], GotoPageWnd, NULL,
  570.             GTIN_Number, next_page_number, TAG_DONE);
  571.         ActivateGadget(GotoPageGadgets[GD_GotoPage], GotoPageWnd, NULL);
  572.         return(0);
  573.     }
  574.     else if(next_page_number > number_of_pages)
  575.     {
  576.         next_page_number = number_of_pages;
  577.         GT_SetGadgetAttrs(GotoPageGadgets[GD_GotoPage], GotoPageWnd, NULL,
  578.             GTIN_Number, next_page_number, TAG_DONE);
  579.         ActivateGadget(GotoPageGadgets[GD_GotoPage], GotoPageWnd, NULL);
  580.         return(0);
  581.     }
  582.     else return(GotoPage_OK);
  583. }
  584.  
  585. int GotoPageCloseWindow( void )
  586. {
  587.     /* routine for "IDCMP_CLOSEWINDOW". */
  588.  
  589.     return(GotoPage_CANCEL);
  590. }
  591.  
  592. int ChoosePSCloseWindow( void )
  593. {
  594.     /* routine for "IDCMP_CLOSEWINDOW". */
  595.  
  596.     return(ChoosePS_CANCEL);
  597. }
  598.  
  599. int ChoosePSVanillaKey( void )
  600. {
  601.     /* routine for "IDCMP_VANILLAKEY". */
  602.  
  603.     switch (ChoosePSMsg.Code)
  604.     {
  605.         case    'c':
  606.         case    'C':
  607.             return(ChoosePS_CANCEL);
  608.  
  609.         case    'o':
  610.         case    'O':
  611.             return(ChoosePS_OK);
  612.     }
  613.     return(0);
  614. }
  615.  
  616. BOOL    do_opts(void)
  617. {
  618.     struct DimensionInfo di;
  619.     BOOL    do_screen = FALSE;
  620.     int    depth_bak;
  621.  
  622.     depth_bak = Options.PostOpts.depth;
  623.     if(Options.PostOpts.depth != TempOptions.PostOpts.depth || 
  624.         Options.Screen.custscreen != TempOptions.Screen.custscreen)
  625.     {
  626.         do_screen = TRUE;
  627.         if(Options.Screen.custscreen)
  628.         {
  629.             if(GetDisplayInfoData(FindDisplayInfo(Options.Screen.ScrDisplayID), (APTR) &di,
  630.                 sizeof(struct DimensionInfo), DTAG_DIMS, Options.Screen.ScrDisplayID))
  631.             {
  632.                 if(di.MaxDepth < TempOptions.PostOpts.depth+1)
  633.                 {
  634.                     okmsg("the current displaymode does not support enough colors!");
  635.                     return(OPT_COLORS);
  636.                 }
  637.             }
  638.         }
  639.     }
  640.     copy_options(&Options, &TempOptions);
  641.     saveterminate();
  642.     sendmenu(PSACTCREATE, 0, 0, 0, NULL, NULL);
  643.     Wait(1L << create_signal);
  644.     if(createerror)
  645.     {
  646.         Options.PostOpts.depth = depth_bak;
  647.         return(OPT_CREATE);
  648.     }
  649.     closewindow();
  650.     if(do_screen)
  651.     {
  652.         if(!Options.Screen.custscreen)
  653.         {
  654.             openpubscreen(&pubscrcontext, pubscreenname);
  655.             if(pubscrcontext.pens_ok == FALSE)
  656.             {
  657.                 okmsg("Can't obtain needed Pens!");
  658.                 GetVisual();
  659.                 UnlockPubScreen(NULL, pubscrcontext.pubscreen);
  660.                 pubscrcontext.ps_lock = FALSE;
  661.                 Options.PostOpts.depth = depth_bak;
  662.                 return(OPT_PENS);
  663.             }
  664.         }
  665.         if (custscreen)        
  666.         {
  667.             while(!CloseScreen(custscreen)) okmsg("you have to close the visitor windows!");
  668.             custscreen = NULL;
  669.         }
  670.         if (Options.Screen.custscreen) openscreen();
  671.     }
  672.     openwindow();
  673.     do_blit();
  674.     runstartupfiles();
  675.     return(FALSE);
  676. }
  677.  
  678. void    do_screen(void)
  679. {
  680.     closewindow();
  681.     if (custscreen)
  682.     {
  683.         while(!CloseScreen(custscreen)) okmsg("you have to close the visitor windows!");
  684.         custscreen = NULL;
  685.     }
  686.     Options.Screen.custscreen = TRUE;
  687.     openscreen();
  688.     openwindow();
  689.     do_blit();
  690. }
  691.  
  692. BOOL    do_pubscreen(void)
  693. {
  694.     struct    Screen    *screen_bak;
  695.  
  696.     if(!Options.Screen.custscreen && !strcmp(newpubscreenname, pubscreenname))
  697.     {
  698.         return(PUB_SAME);
  699.     }
  700.     screen_bak = screen;
  701.     if(openpubscreen(&newpubscrcontext, newpubscreenname) == FALSE)
  702.     {
  703.         return(PUB_SCREEN);
  704.     }
  705.     else if(newpubscrcontext.pens_ok == FALSE)
  706.     {
  707.         okmsg("Can't obtain needed Pens!");
  708.         UnlockPubScreen(NULL, newpubscrcontext.pubscreen);
  709.         screen = screen_bak;
  710.         return(OPT_PENS);
  711.     }
  712.     closewindow();
  713.     if (custscreen)
  714.     {
  715.         while(!CloseScreen(custscreen)) okmsg("you have to close the visitor windows!");
  716.         custscreen = NULL;
  717.     }
  718.     Options.Screen.custscreen = FALSE;
  719.     strcpy(pubscreenname, newpubscreenname);
  720.     strcpy(Options.Screen.pubscrname, newpubscreenname);
  721.     pubscrcontext = newpubscrcontext;
  722.     screen = newpubscrcontext.pubscreen;
  723.     ScreenToFront(screen);
  724.     openwindow();
  725.     do_blit();
  726.     return(FALSE);
  727. }
  728.